#!/usr/bin/env python3
"""
停止API服务器
通过向服务器发送关闭请求来优雅地关闭API服务
"""

import requests
import sys
import time
import argparse


def stop_api_server(host='localhost', port=5000, timeout=10):
    """
    停止API服务器
    
    Args:
        host: 服务器主机地址
        port: 服务器端口
        timeout: 超时时间（秒）
        
    Returns:
        bool: 是否成功停止
    """
    api_url = f"http://{host}:{port}"
    
    try:
        # 首先检查服务器是否在运行
        print(f"检查API服务器状态 ({api_url})...")
        health_response = requests.get(f"{api_url}/api/health", timeout=5)
        
        if health_response.status_code != 200:
            print("API服务器似乎没有运行")
            return False
            
        print("API服务器正在运行，准备停止...")
        
        # 尝试发送停止请求
        try:
            stop_response = requests.post(f"{api_url}/api/shutdown", timeout=timeout)
            
            if stop_response.status_code == 200:
                result = stop_response.json()
                if result.get('success'):
                    print("[成功] API服务器已成功停止")
                    return True
                else:
                    print(f"[失败] 停止失败: {result.get('message', '未知错误')}")
                    return False
            else:
                print(f"[警告] shutdown端点不可用 (HTTP {stop_response.status_code})，尝试强制停止...")
                return False
        except requests.exceptions.ConnectionError:
            # 连接错误可能意味着服务器已经停止
            print("[信息] 服务器连接已断开，可能已停止")
            return True
            
    except requests.exceptions.ConnectionError:
        print("[失败] 无法连接到API服务器，可能已经停止或未启动")
        return False
    except requests.exceptions.Timeout:
        print(f"[失败] 请求超时（{timeout}秒）")
        return False
    except Exception as e:
        print(f"[失败] 停止服务器时发生错误: {e}")
        return False


def main():
    """主函数"""
    parser = argparse.ArgumentParser(description='停止红外温度分析API服务器')
    parser.add_argument('--host', default='localhost', help='服务器主机地址 (默认: localhost)')
    parser.add_argument('--port', type=int, default=5000, help='服务器端口 (默认: 5000)')
    parser.add_argument('--timeout', type=int, default=10, help='超时时间秒数 (默认: 10)')
    parser.add_argument('--force', action='store_true', help='强制终止服务器进程')
    
    args = parser.parse_args()
    
    print("红外温度分析系统 - API服务器停止工具")
    print("=" * 50)
    
    success = stop_api_server(args.host, args.port, args.timeout)
    
    if not success:
        print("\n使用强制模式停止服务器...")
        success = force_stop_server(args.port)
    
    if success:
        print("\n[完成] API服务器已停止")
        sys.exit(0)
    else:
        print("\n[错误] 停止API服务器失败")
        sys.exit(1)


def force_stop_server(port=5000):
    """
    强制停止服务器进程
    
    Args:
        port: 要停止的端口号
        
    Returns:
        bool: 是否成功停止
    """
    import platform
    import subprocess
    
    try:
        if platform.system() == "Windows":
            # Windows系统：使用netstat和taskkill
            print(f"查找占用端口 {port} 的进程...")
            
            # 查找占用端口的进程
            result = subprocess.run(
                ['netstat', '-ano'], 
                capture_output=True, 
                text=True, 
                encoding='gbk'
            )
            
            if result.returncode != 0:
                print("[失败] 无法执行netstat命令")
                return False
            
            lines = result.stdout.split('\n')
            target_pid = None
            
            for line in lines:
                if f":{port}" in line and "LISTENING" in line:
                    parts = line.split()
                    if len(parts) >= 5:
                        target_pid = parts[-1]
                        break
            
            if target_pid:
                print(f"找到进程PID: {target_pid}")
                
                # 使用taskkill终止进程
                kill_result = subprocess.run(
                    ['taskkill', '/PID', target_pid, '/F'],
                    capture_output=True,
                    text=True,
                    encoding='gbk'
                )
                
                if kill_result.returncode == 0:
                    print(f"[成功] 进程 {target_pid} 已强制终止")
                    return True
                else:
                    print(f"[失败] 无法终止进程 {target_pid}: {kill_result.stderr}")
                    return False
            else:
                print(f"未找到占用端口 {port} 的进程")
                return False
                
        else:
            # Unix/Linux系统：使用lsof和kill
            try:
                import psutil
                
                print(f"查找占用端口 {port} 的进程...")
                
                for proc in psutil.process_iter(['pid', 'name', 'connections']):
                    try:
                        for conn in proc.info['connections'] or []:
                            if conn.laddr.port == port:
                                print(f"找到进程: PID={proc.info['pid']}, 名称={proc.info['name']}")
                                
                                # 终止进程
                                process = psutil.Process(proc.info['pid'])
                                process.terminate()
                                
                                # 等待进程结束
                                try:
                                    process.wait(timeout=5)
                                    print(f"[成功] 进程 {proc.info['pid']} 已停止")
                                    return True
                                except psutil.TimeoutExpired:
                                    # 强制杀死进程
                                    process.kill()
                                    print(f"[强制] 强制终止进程 {proc.info['pid']}")
                                    return True
                                    
                    except (psutil.NoSuchProcess, psutil.AccessDenied):
                        continue
                        
                print(f"未找到占用端口 {port} 的进程")
                return False
                
            except ImportError:
                print("[错误] Unix系统需要安装 psutil 库: pip install psutil")
                return False
        
    except Exception as e:
        print(f"[错误] 强制停止时发生错误: {e}")
        return False


if __name__ == "__main__":
    main()